// 碰撞监控WebSocket服务
// 用于在后台持续监听位置信息并接收碰撞警报

import LocationData from './locationModel.js';

let socket = null;
let isConnected = false;
let reconnectTimer = null;
let locationTimer = null;
let reconnectCount = 0;
let locationFailCount = 0;

// WebSocket服务器地址
const WS_URL = 'ws://localhost:8080/websocket/location';

// 配置
const CONFIG = {
  // 位置发送间隔 (毫秒) - 降低到300ms以提高实时性
  SEND_INTERVAL: 300,
  // 重连间隔基础时间 (毫秒)
  RECONNECT_INTERVAL_BASE: 1000,
  // 最大重连次数
  MAX_RECONNECT_COUNT: 10,
  // 是否开启调试日志
  DEBUG: true,
  // 服务器地址
  SERVER_URL: 'ws://localhost:8080/ws',
  // 位置服务配置
  LOCATION: {
    // 位置更新最小时间间隔(ms)
    MIN_TIME: 100,
    // 位置更新最小距离变化(米)
    MIN_DISTANCE: 0.2,
    // 允许后台定位
    BACKGROUND: true,
    // 是否优先使用系统传感器数据
    USE_SENSORS: true
  }
};

// 缓存上一次的位置信息，用于减少重复发送
let lastPosition = null;
let lastSentPosition = null;
// 位置监听器
let locationWatcher = null;

/**
 * 打印调试日志
 */
function debugLog(...args) {
  if (CONFIG.DEBUG) {
    console.log('[LocationService]', ...args);
  }
}

/**
 * 初始化WebSocket连接
 */
function initWebSocket() {
  if (socket) {
    try {
      socket.close();
    } catch (e) {
      debugLog('关闭旧连接出错:', e);
    }
    socket = null;
  }
  
  try {
    debugLog('尝试连接WebSocket:', WS_URL);
    
    // 使用uni-app的WebSocket API
    socket = uni.connectSocket({
      url: WS_URL,
      header: {
        'content-type': 'application/json',
        // 使用keep-alive减少连接建立时间
        'Connection': 'keep-alive'
      },
      // 使用较低的超时，快速失败并重连
      timeout: 5000,
      method: 'GET',
      // 设置tcpNoDelay=true减少网络数据包延迟
      tcpNoDelay: true,
      success: (res) => {
        debugLog('WebSocket连接请求成功发送');
      },
      fail: (err) => {
        debugLog('WebSocket连接请求发送失败:', err);
        reconnect();
      },
      complete: () => {}
    });
    
    if (!socket) {
      debugLog('WebSocket创建失败');
      reconnect();
      return;
    }
    
    // 监听WebSocket连接打开
    socket.onOpen((res) => {
      debugLog('WebSocket连接已打开', res);
      isConnected = true;
      reconnectCount = 0;
      clearTimeout(reconnectTimer);
      startSendingLocation();
      
      // 连接成功后立即发送一次位置数据
      sendLocationData();
    });
    
    // 监听WebSocket错误
    socket.onError((err) => {
      debugLog('WebSocket错误:', err);
      isConnected = false;
      reconnect();
    });
    
    // 监听WebSocket关闭
    socket.onClose((res) => {
      debugLog('WebSocket连接已关闭', res);
      isConnected = false;
      reconnect();
    });
    
    // 监听WebSocket消息
    socket.onMessage((res) => {
      try {
        const data = res.data;
        debugLog('收到原始消息:', data);
        
        // 立即检查是否包含关键词
        if (typeof data === 'string') {
          // 直接检查是否包含安全距离=false的文本
          if (data.includes('安全距离=false')) {
            debugLog('⚠️ 检测到安全距离=false，立即触发警报');
            
            // 立即执行震动
            uni.vibrateLong();
            
            // 立即播放警告声音
            const innerAudioContext = uni.createInnerAudioContext();
            innerAudioContext.src = '/static/warning.mp3';
            innerAudioContext.play();
            
            // 使用自动消失的警告提示
            showAutoDisappearingWarning('检测到车辆距离不安全！请注意避让。');
            
            return;
          }
          
          // 检查其他警告信息
          if (data.includes('警告') || data.includes('碰撞风险') || data.includes('接近速度')) {
            handleTextMessage(data);
            return;
          }
        }
        
        // 其他消息交给一般处理函数
        handleWebSocketMessage(res);
      } catch (e) {
        debugLog('消息处理错误:', e);
      }
    });
  } catch (e) {
    debugLog('初始化WebSocket失败:', e);
    reconnect();
  }
}

/**
 * 重新连接WebSocket
 */
function reconnect() {
  clearTimeout(reconnectTimer);
  clearInterval(locationTimer);
  
  // 超过最大重连次数，停止尝试
  if (reconnectCount >= CONFIG.MAX_RECONNECT_COUNT) {
    debugLog(`已达到最大重连次数(${CONFIG.MAX_RECONNECT_COUNT})，停止重连`);
    // 可以在这里通知用户连接失败
    uni.showToast({
      title: '连接服务器失败，请检查网络',
      icon: 'none',
      duration: 3000
    });
    return;
  }
  
  reconnectCount++;
  const delay = reconnectCount * CONFIG.RECONNECT_INTERVAL_BASE;
  
  debugLog(`尝试第${reconnectCount}次重连，将在${delay/1000}秒后重试...`);
  
  reconnectTimer = setTimeout(() => {
    initWebSocket();
  }, delay);
}

/**
 * 开始定期发送位置数据
 */
function startSendingLocation() {
  clearInterval(locationTimer);
  
  // 立即发送一次位置数据
  sendLocationData();
  
  // 尝试使用持续监听位置，比定时获取更实时
  try {
    if (uni.offLocationChange && locationWatcher) {
      // 先清除之前的监听
      uni.offLocationChange(locationWatcher);
    }
    
    // 开启实时位置监听（如果平台支持）
    if (uni.onLocationChange) {
      locationWatcher = (res) => {
        if (isConnected) {
          // 有新的位置更新，直接处理
          handleLocationUpdate(res);
        }
      };
      
      debugLog('开启持续位置监听');
      uni.startLocationUpdate({
        success: () => {
          uni.onLocationChange(locationWatcher);
          debugLog('持续位置监听已开启');
          
          // 启动高频率位置报告
          try {
            // 尝试设置最高频率的位置更新（仅部分平台支持）
            uni.setLocationOptions && uni.setLocationOptions({
              highAccuracyExpireTime: 0, // 持续高精度
              accuracyAuthorization: 'reduced' // 较高精度
            });
            debugLog('已设置高精度位置选项');
          } catch (e) {
            debugLog('设置位置选项失败:', e);
          }
        },
        fail: (err) => {
          debugLog('持续位置监听失败，切换到定时获取模式:', err);
          // 如果持续监听失败，则切换到定时获取模式
          startLocationTimer();
        }
      });
    } else {
      // 平台不支持持续监听，切换到定时获取模式
      debugLog('当前平台不支持持续位置监听，切换到定时获取模式');
      startLocationTimer();
    }
  } catch (e) {
    debugLog('设置位置监听出错，切换到定时获取模式:', e);
    startLocationTimer();
  }
}

/**
 * 启动定时获取位置的模式
 */
function startLocationTimer() {
  // 然后定期发送
  locationTimer = setInterval(() => {
    if (isConnected) {
      sendLocationData();
    } else {
      debugLog('WebSocket未连接，暂停位置发送');
    }
  }, CONFIG.SEND_INTERVAL);  // 每0.5秒发送一次
}

/**
 * 计算两个坐标点之间的距离（米）
 * @param {number} lat1 第一个点的纬度
 * @param {number} lon1 第一个点的经度
 * @param {number} lat2 第二个点的纬度
 * @param {number} lon2 第二个点的经度
 * @return {number} 距离，单位米
 */
function calculateDistance(lat1, lon1, lat2, lon2) {
  if (typeof lat1 !== 'number' || typeof lon1 !== 'number' || 
      typeof lat2 !== 'number' || typeof lon2 !== 'number') {
    return 0;
  }
  
  // 如果坐标完全相同，直接返回0
  if (lat1 === lat2 && lon1 === lon2) {
    return 0;
  }
  
  // 转换为弧度
  const radLat1 = (lat1 * Math.PI) / 180;
  const radLon1 = (lon1 * Math.PI) / 180;
  const radLat2 = (lat2 * Math.PI) / 180;
  const radLon2 = (lon2 * Math.PI) / 180;
  
  // 地球半径(m)
  const R = 6371000;
  
  // 使用Haversine公式计算
  const dLat = radLat2 - radLat1;
  const dLon = radLon2 - radLon1;
  const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
    Math.cos(radLat1) * Math.cos(radLat2) *
    Math.sin(dLon / 2) * Math.sin(dLon / 2);
  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
  const distance = R * c;
  
  return distance;
}

/**
 * 处理从位置监听器获取的位置更新
 * @param {Object} res 位置信息
 */
function handleLocationUpdate(res) {
  if (!isConnected || !res) return;
  
  // 记录当前时间戳
  const timestamp = Date.now();
  
  // 检查数据有效性
  if (typeof res.latitude !== 'number' || typeof res.longitude !== 'number') {
    debugLog('位置数据无效，跳过更新');
    return;
  }
  
  // 始终发送位置数据到后端
  let shouldSend = true;
  let distChange = 0;
  
  if (lastSentPosition) {
    // 计算与上次发送位置的距离变化（仅用于记录）
    distChange = calculateDistance(
      lastSentPosition.latitude, lastSentPosition.longitude,
      res.latitude, res.longitude
    );
    
    // 不再判断位置是否相同，始终发送
    debugLog('持续发送位置数据，距离变化:', distChange);
  }
  
  // 如果需要发送
  if (shouldSend) {
    // 获取用户ID
    const userId = getStoredUserId();
    
    // 构建发送的数据
    const locationData = {
      id: userId,
      longitude: res.longitude,
      latitude: res.latitude,
      accuracy: res.accuracy || 0,
      timestamp: timestamp
    };
    
    // 发送数据
    try {
      const jsonStr = JSON.stringify(locationData);
      sendMessage(jsonStr);
      debugLog('发送新位置数据:', res.longitude, res.latitude);
      
      // 更新最后发送的位置
      lastSentPosition = {
        latitude: res.latitude,
        longitude: res.longitude,
        timestamp: timestamp
      };
    } catch (e) {
      debugLog('发送位置数据失败:', e);
    }
  }
  
  // 无论是否发送，都更新lastPosition
  lastPosition = {
    latitude: res.latitude,
    longitude: res.longitude,
    timestamp: timestamp
  };
}

/**
 * 获取当前位置并发送到服务器
 */
function sendLocationData() {
  if (!isConnected) {
    debugLog('WebSocket未连接，无法发送位置数据');
    return;
  }
  
  // 从存储或全局状态获取用户ID
  const userId = getStoredUserId();
  
  // 使用高精度定位，强制刷新位置数据
  uni.getLocation({
    type: 'gcj02',
    // 高精度模式
    isHighAccuracy: true,
    // 减少高精度定位超时时间，加快定位速度
    highAccuracyExpireTime: 1000,
    // 优先使用GPS定位
    altitude: true,
    // 不使用缓存，强制获取新位置
    geocode: false,
    // 添加随机参数，防止系统缓存位置结果
    // 每次请求使用不同的时间戳强制刷新
    _timestamp: Date.now() + Math.random(),
    complete: () => {},
    success: (res) => {
      // 记录获取位置时间，用于检测位置是否更新
      const timestamp = Date.now();
      
      // 直接使用简单对象，减少处理步骤
      const locationData = {
        id: userId,
        longitude: res.longitude,
        latitude: res.latitude,
        // 附加精度信息，帮助后端判断位置可靠性
        accuracy: res.accuracy || 0,
        // 附加当前时间戳，减少时间偏差
        timestamp: timestamp
      };
      
      // 始终发送位置数据，不判断是否变化
      let isLocationChanged = true;
      let shouldSend = true;
      
      if (lastSentPosition) {
        // 记录位置信息但始终发送
        debugLog('持续发送位置数据');
      }
      
      if (lastPosition) {
        // 计算与上次位置的距离
        const distChange = calculateDistance(
          lastPosition.latitude, lastPosition.longitude,
          res.latitude, res.longitude
        );
        
        // 检查时间变化
        const timeChange = timestamp - lastPosition.timestamp;
        
        // 如果位置完全没变但时间差超过3秒，可能是位置没更新
        if (distChange < 0.1 && timeChange > 3000) {
          // 位置没变化但已经过了很长时间，可能是缓存问题
          debugLog('警告：位置数据可能未更新，尝试强制刷新', timeChange/1000, '秒');
          
          // 尝试重置位置服务
          resetLocationServices();
          
          // 标记为可能不准确但继续发送
          locationData.may_inaccurate = true;
        }
        
        // 始终发送数据
        shouldSend = true;
        
        // 更新lastPosition
        lastPosition = {
          latitude: res.latitude,
          longitude: res.longitude,
          timestamp: timestamp
        };
      } else {
        // 首次获取位置
        lastPosition = {
          latitude: res.latitude,
          longitude: res.longitude,
          timestamp: timestamp
        };
        // 首次获取位置时始终发送
        shouldSend = true;
      }
      
      if (shouldSend) {
        try {
          // 直接发送JSON字符串，跳过额外的转换
          const jsonStr = JSON.stringify(locationData);
          sendMessage(jsonStr);
          debugLog('发送位置数据:', res.longitude, res.latitude);
          
          // 更新最后发送的位置
          lastSentPosition = {
            latitude: res.latitude,
            longitude: res.longitude,
            timestamp: timestamp
          };
        } catch (e) {
          debugLog('位置数据发送失败:', e);
        }
      }
    },
    fail: (err) => {
      debugLog('获取位置失败:', err);
      
      // 如果连续失败多次，尝试重置位置服务
      locationFailCount = (locationFailCount || 0) + 1;
      if (locationFailCount > 3) {
        resetLocationServices();
        locationFailCount = 0;
      }
      
      checkLocationPermission();
    }
  });
}

/**
 * 重置位置服务，解决位置更新问题
 */
function resetLocationServices() {
  debugLog('重置位置服务以解决位置更新问题');
  
  // 停止所有现有的位置监听
  try {
    if (uni.offLocationChange && locationWatcher) {
      uni.stopLocationUpdate();
      uni.offLocationChange(locationWatcher);
      locationWatcher = null;
    }
  } catch (e) {
    debugLog('停止位置监听出错:', e);
  }
  
  // 清除位置缓存（部分平台支持）
  try {
    if (uni.cleanLocationCache) {
      uni.cleanLocationCache();
      debugLog('位置缓存已清除');
    }
  } catch (e) {
    debugLog('清除位置缓存失败:', e);
  }
  
  // 尝试主动清除设备缓存
  try {
    // 在微信小程序环境下
    const systemInfo = uni.getSystemInfoSync();
    if (systemInfo.appName === 'WECHAT' && wx) {
      // 强制重置微信定位系统
      if (wx.offLocationChange) {
        wx.offLocationChange();
      }
      if (wx.stopLocationUpdate) {
        wx.stopLocationUpdate();
      }
      // 清除所有位置监听器
      locationWatcher = null;
    }
  } catch (e) {
    debugLog('重置平台特定位置服务失败:', e);
  }
  
  // 立即获取一次新位置（不使用缓存）
  uni.getLocation({
    type: 'gcj02',
    isHighAccuracy: true,
    highAccuracyExpireTime: 1000,
    altitude: true,
    geocode: false,
    _forceRefresh: Date.now() + Math.random(),
    success: (res) => {
      debugLog('强制刷新位置成功:', res.longitude, res.latitude);
      // 立即更新全局位置记录
      lastPosition = {
        latitude: res.latitude,
        longitude: res.longitude,
        timestamp: Date.now()
      };
      // 快速重启位置服务
      setTimeout(() => {
        startHighFrequencyLocation();
      }, 200);
    },
    fail: () => {
      // 延迟稍长时间重启位置服务
      setTimeout(() => {
        startHighFrequencyLocation();
      }, 500);
    }
  });
  
  // 不再显示刷新位置数据的提示
}

/**
 * 检查位置权限
 */
function checkLocationPermission() {
  uni.getSetting({
    success: (res) => {
      if (!res.authSetting['scope.userLocation']) {
        uni.showModal({
          title: '位置权限提醒',
          content: '需要位置权限来监控碰撞风险，请在设置中开启',
          confirmText: '去设置',
          success: (modalRes) => {
            if (modalRes.confirm) {
              uni.openSetting();
            }
          }
        });
      }
    }
  });
}

/**
 * 发送消息到WebSocket服务器
 */
function sendMessage(message) {
  if (isConnected && socket) {
    try {
      // 标记为高优先级传输
      socket.send({
        data: message,
        // 增加成功回调以确认数据已发送
        success: () => {
          // 只在调试模式记录日志，减少不必要处理
          if (CONFIG.DEBUG) {
            debugLog('消息发送成功');
          }
        },
        fail: (err) => {
          debugLog('消息发送失败:', err);
          // 消息发送失败可能表示连接已断开但状态未更新
          if (isConnected) {
            isConnected = false;
            reconnect();
          }
        }
      });
    } catch (e) {
      debugLog('发送消息出错:', e);
      if (isConnected) {
        isConnected = false;
        reconnect();
      }
    }
  } else {
    debugLog('WebSocket未连接，无法发送消息');
  }
}

/**
 * 处理WebSocket消息
 */
function handleWebSocketMessage(res) {
  try {
    debugLog('收到消息:', res.data);
    
    const data = res.data;
    
    // 检查是否包含"安全距离=false"的文本信息
    if (typeof data === 'string' && data.includes('安全距离=false')) {
      handleTextMessage(data);
      return;
    }
    
    // 尝试解析JSON，如果不是有效的JSON则作为文本消息处理
    try {
      const jsonData = JSON.parse(data);
      
      // 检查JSON是否包含安全距离字段
      if (jsonData.safeDistance === false) {
        handleTextMessage(`警告：检测到碰撞风险！距离：${jsonData.distance}米`);
        return;
      }
      
      handleCollisionWarning(jsonData);
    } catch (e) {
      // 如果不是JSON，则作为文本消息处理
      handleTextMessage(data);
    }
  } catch (e) {
    debugLog('处理消息出错:', e);
  }
}

/**
 * 处理文本消息（警报消息）
 */
function handleTextMessage(message) {
  debugLog('收到文本消息:', message);
  
  // 检查消息是否包含警告关键词或安全距离=false
  if ((message.includes('警告') || message.includes('碰撞') || message.includes('风险') || 
      message.includes('安全距离=false'))) {
    // 立即执行震动提醒
    uni.vibrateLong();
    
    // 立即播放警告声音
    const innerAudioContext = uni.createInnerAudioContext();
    innerAudioContext.src = '/static/warning.mp3';
    innerAudioContext.play();
    
    // 使用自动消失的通知，而非需要点击确定的对话框
    showAutoDisappearingWarning(message);
  } else if (message.includes('通知') || message.includes('解除')) {
    // 显示解除警报通知
    uni.showToast({
      title: message,
      icon: 'success',
      duration: 3000
    });
  }
}

/**
 * 显示自动消失的警告通知
 * @param {string} message 警告消息
 */
function showAutoDisappearingWarning(message) {
  // 震动提醒
  uni.vibrateLong();
  
  // 短暂延迟后再次震动，增强警告效果
  setTimeout(() => {
    uni.vibrateLong();
  }, 800);
  
  // 播放警告声音
  try {
    const innerAudioContext = uni.createInnerAudioContext();
    innerAudioContext.src = '/static/warning.mp3';
    innerAudioContext.play();
  } catch (e) {
    debugLog('播放声音失败:', e);
  }

  // 不显示Toast，改为直接使用居中警告
  
  // 同时显示状态栏通知（部分平台支持）
  try {
    if (uni.setNavigationBarColor) {
      uni.setNavigationBarColor({
        frontColor: '#ffffff',
        backgroundColor: '#ff0000',
        animation: {
          duration: 200,
          timingFunc: 'easeIn'
        }
      });
      
      // 5秒后恢复
      setTimeout(() => {
        uni.setNavigationBarColor({
          frontColor: '#000000',
          backgroundColor: '#F8F8F8',
          animation: {
            duration: 200,
            timingFunc: 'easeOut'
          }
        });
      }, 5000);
    }
  } catch (e) {
    debugLog('设置导航栏颜色失败:', e);
  }
  
  // 直接显示居中的自动消失警告
  showFloatingWarning(message);
}

/**
 * 显示浮动警告
 * @param {string} message 警告消息
 */
function showFloatingWarning(message) {
  try {
    // 使用自定义样式的全屏遮罩Toast，完全自动消失
    const warningToast = {
      title: '⚠️ 碰撞警告',
      icon: 'none',
      // 显示在屏幕中央
      position: 'center',
      // 显示内容
      message: message,
      // 红色警告样式
      image: '/static/warning.png',
      // 5秒后自动消失
      duration: 5000,
      // 使用遮罩阻止其他交互，增强警告效果
      mask: true
    };
    
    // 显示警告Toast
    uni.showToast({
      title: '⚠️ 碰撞警告\n' + message + '\n\n系统将自动处理',
      icon: 'none',
      position: 'center',
      duration: 5000,
      mask: true
    });
    
    // 在某些平台，需要设置长一点的持续时间
    // 微信小程序环境下增强处理
    try {
      const systemInfo = uni.getSystemInfoSync();
      if (systemInfo.appName === 'WECHAT' && wx) {
        wx.showToast({
          title: '⚠️ 碰撞警告\n' + message,
          icon: 'none',
          duration: 5000,
          mask: true
        });
      }
    } catch (e) {
      // 忽略平台检测错误
    }
    
    // 使用备份定时器确保警告会消失
    if (global._warningAutoHideTimer) {
      clearTimeout(global._warningAutoHideTimer);
    }
    
    // 6秒后强制清除所有可能的提示
    global._warningAutoHideTimer = setTimeout(() => {
      uni.hideToast();
      uni.hideLoading();
      try {
        wx && wx.hideToast && wx.hideToast();
      } catch (e) {}
    }, 6000);
  } catch (e) {
    debugLog('显示自动消失警告失败:', e);
    
    // 终极备用方案：使用showLoading，它在hideLoading时会自动消失
    uni.showLoading({
      title: '⚠️ 碰撞警告: ' + message,
      mask: true
    });
    
    // 5秒后关闭
    setTimeout(() => {
      uni.hideLoading();
    }, 5000);
  }
}

/**
 * 处理碰撞警告
 */
function handleCollisionWarning(data) {
  // 如果收到了碰撞警告
  if (data && data.type === 'collision_warning') {
    debugLog('收到碰撞警告:', data);
    
    // 使用自动消失的警告，不需要用户点击确定
    const warningMessage = `检测到与ID: ${data.otherId} 可能发生碰撞!\n当前距离: ${data.distance}米\n接近速度: ${data.speed}米/秒`;
    showAutoDisappearingWarning(warningMessage);
    
    // 播放警告声音和震动已在showAutoDisappearingWarning中处理
  }
}

/**
 * 获取存储的用户ID
 */
function getStoredUserId() {
  // 从缓存中获取用户ID
  const userId = uni.getStorageSync('userId');
  
  // 如果找不到ID，返回默认值1
  if (!userId) {
    // 设置默认ID
    uni.setStorageSync('userId', '1');
    return '1';
  }
  
  return userId;
}

/**
 * 开始高频率位置发送
 * 使用替代方案实现0.5秒的位置发送频率
 */
function startHighFrequencyLocation() {
  debugLog('开始高频率位置发送');
  
  // 清除位置缓存（在有些平台上可能有帮助）
  try {
    if (uni.cleanLocationCache) {
      uni.cleanLocationCache();
    }
  } catch (e) {
    debugLog('清除位置缓存失败:', e);
  }
  
  // 先授权和配置
  uni.authorize({
    scope: 'scope.userLocation',
    success: () => {
      debugLog('位置权限已授权');
      
      // 配置位置更新 - 使用最高精度和更新频率
      if (uni.setLocationOptions) {
        uni.setLocationOptions({
          accuracy: 'high',
          highAccuracyExpireTime: 0,
          isHighAccuracy: true,
          allowsBackgroundLocationUpdates: true,
          // 设置更快的位置更新间隔
          interval: CONFIG.LOCATION.MIN_TIME,
          // 设置更低的最小位置变化阈值
          distanceFilter: CONFIG.LOCATION.MIN_DISTANCE
        });
      }
      
      // 方式1: 使用更高频率的setInterval定时获取
      clearInterval(locationTimer);
      locationTimer = setInterval(() => {
        if (isConnected) {
          sendLocationData();
        }
      }, CONFIG.SEND_INTERVAL);
      
      // 方式2: 并行使用更激进的位置刷新定时器
      // 增加一个更高频率的位置刷新，提高位置更新及时性
      if (global._fastLocationTimer) {
        clearInterval(global._fastLocationTimer);
      }
      
      global._fastLocationTimer = setInterval(() => {
        if (isConnected) {
          // 强制获取一次位置，并跳过缓存
          uni.getLocation({
            type: 'gcj02',
            isHighAccuracy: true,
            highAccuracyExpireTime: 500,
            _forceRefresh: Date.now() + Math.random(),
            success: (res) => {
              if (res && typeof res.latitude === 'number') {
                handleLocationUpdate(res);
              }
            }
          });
        }
      }, 1000); // 每1秒刷新一次位置，作为备用更新机制
      
      // 方式3: 尝试启动系统位置更新（实时更新）
      try {
        if (uni.startLocationUpdate) {
          // 停止旧的监听
          if (locationWatcher) {
            try {
              uni.offLocationChange(locationWatcher);
              uni.stopLocationUpdate();
            } catch (e) {}
          }
          
          // 先设置监听器
          locationWatcher = (res) => {
            if (isConnected) {
              // 检查res是否有效
              if (res && typeof res.latitude === 'number' && typeof res.longitude === 'number') {
                // 立即处理位置更新
                handleLocationUpdate(res);
              }
            }
          };
          
          // 再启动位置更新 - 指定更高精度配置
          uni.onLocationChange(locationWatcher);
          uni.startLocationUpdate({
            type: 'gcj02',
            isHighAccuracy: true,
            success: () => {
              debugLog('持续位置监听已开启');
            },
            fail: (err) => {
              debugLog('持续位置监听失败:', err);
            }
          });
        }
      } catch (e) {
        debugLog('启动位置监听出错:', e);
      }
      
      // 方式4: 尝试使用平台特定API
      try {
        // 平台检测
        const systemInfo = uni.getSystemInfoSync();
        const platform = systemInfo.platform || '';
        const isWechat = systemInfo.appName === 'WECHAT' || false;
        
        // 微信小程序环境 - 使用微信特有的高精度定位能力
        if (isWechat && wx) {
          // 尝试使用微信高精度定位API
          if (wx.startLocationUpdateBackground) {
            wx.startLocationUpdateBackground({
              type: 'gcj02',
              success: () => {
                debugLog('微信后台位置更新已开启');
                
                // 注册位置变化监听
                wx.onLocationChange((res) => {
                  if (isConnected && res) {
                    // 使用高优先级处理微信位置更新
                    handleLocationUpdate(res);
                  }
                });
              },
              fail: (err) => {
                debugLog('开启微信后台位置更新失败:', err);
                
                // 如果后台定位失败，尝试使用前台定位
                if (wx.startLocationUpdate) {
                  wx.startLocationUpdate({
                    type: 'gcj02',
                    success: () => {
                      debugLog('微信前台位置更新已开启');
                    }
                  });
                }
              }
            });
          } 
          // 如果不支持后台定位，使用前台定位
          else if (wx.startLocationUpdate) {
            wx.startLocationUpdate({
              type: 'gcj02',
              success: () => {
                debugLog('微信前台位置更新已开启');
              }
            });
          }
          
          // 强制启用小程序位置变化事件
          if (wx.onLocationChange) {
            wx.onLocationChange((res) => {
              if (isConnected && res) {
                handleLocationUpdate(res);
              }
            });
          }
        }
      } catch (e) {
        debugLog('尝试使用平台特定API失败:', e);
      }
    },
    fail: (err) => {
      debugLog('位置权限未授权:', err);
      checkLocationPermission();
    }
  });
  
  // 设置位置刷新定时器，每10秒强制刷新一次位置服务
  if (global._locationRefreshTimer) {
    clearInterval(global._locationRefreshTimer);
  }
  
  global._locationRefreshTimer = setInterval(() => {
    // 检查最后一次位置更新是否过期（10秒无更新）
    const now = Date.now();
    if (lastPosition && (now - lastPosition.timestamp > 10000)) {
      debugLog('位置长时间未更新，强制刷新位置服务');
      resetLocationServices();
    }
  }, 10000); // 每10秒检查一次，更快地检测位置更新问题
}

/**
 * 停止所有位置监听方法
 */
function stopAllLocationWatchers() {
  // 清理setInterval
  if (locationTimer) {
    clearInterval(locationTimer);
    locationTimer = null;
  }
  
  // 清理uni API的位置监听
  if (uni.offLocationChange && locationWatcher) {
    try {
      uni.stopLocationUpdate();
      uni.offLocationChange(locationWatcher);
      locationWatcher = null;
    } catch (e) {
      debugLog('停止uni位置监听出错:', e);
    }
  }
  
  // 清理平台特定API
  try {
    const platformObj = uni.getSystemInfoSync().platform === 'ios' ? 'wx' : 
                        uni.getSystemInfoSync().platform === 'android' ? 'wx' : 'uni';
                        
    if (platformObj !== 'uni' && platformObj.stopLocationUpdate) {
      platformObj.stopLocationUpdate();
    }
  } catch (e) {
    debugLog('停止平台特定位置API出错:', e);
  }
  
  // 清理Web API
  try {
    if (typeof navigator !== 'undefined' && navigator.geolocation && 
        global._webLocationWatchId !== undefined) {
      navigator.geolocation.clearWatch(global._webLocationWatchId);
      global._webLocationWatchId = undefined;
    }
  } catch (e) {
    debugLog('停止Web位置API出错:', e);
  }
}

/**
 * 停止位置服务
 */
function stopLocationService() {
  debugLog('停止位置服务');
  
  // 清除所有定时器
  if (locationTimer) {
    clearInterval(locationTimer);
    locationTimer = null;
  }
  
  // 清除位置刷新定时器
  if (global._locationRefreshTimer) {
    clearInterval(global._locationRefreshTimer);
    global._locationRefreshTimer = null;
  }
  
  // 清除快速位置刷新定时器
  if (global._fastLocationTimer) {
    clearInterval(global._fastLocationTimer);
    global._fastLocationTimer = null;
  }
  
  // 停止uni-app位置监听
  try {
    if (uni.offLocationChange && locationWatcher) {
      uni.offLocationChange(locationWatcher);
      uni.stopLocationUpdate();
      locationWatcher = null;
    }
  } catch (e) {
    debugLog('停止uni位置监听出错:', e);
  }
  
  // 清除位置缓存
  try {
    if (uni.cleanLocationCache) {
      uni.cleanLocationCache();
    }
  } catch (e) {
    debugLog('清除位置缓存失败:', e);
  }
  
  // 停止微信特定API
  try {
    const systemInfo = uni.getSystemInfoSync();
    const isWechat = systemInfo.appName === 'WECHAT' || false;
    
    if (isWechat && wx) {
      // 停止并清除微信位置更新
      if (wx.stopLocationUpdate) {
        wx.stopLocationUpdate();
      }
      if (wx.offLocationChange) {
        wx.offLocationChange();
      }
      // 确保后台定位也被停止
      if (wx.stopLocationUpdateBackground) {
        wx.stopLocationUpdateBackground();
      }
    }
  } catch (e) {
    debugLog('停止平台特定位置服务出错:', e);
  }
  
  // 清除位置相关数据
  lastPosition = null;
  lastSentPosition = null;
  locationFailCount = 0;
  
  debugLog('所有位置服务已停止');
}

// 导出服务方法
export default {
  /**
   * 启动位置监控服务
   */
  startMonitoring() {
    debugLog('启动位置监控服务');
    reconnectCount = 0;
    
    // 初始化WebSocket连接
    initWebSocket();
    
    // 启动高频率位置发送（每0.5秒一次）
    startHighFrequencyLocation();
  },
  
  /**
   * 停止位置监控服务
   */
  stopMonitoring() {
    debugLog('停止位置监控服务');
    
    // 停止所有位置监听
    stopAllLocationWatchers();
    
    // 停止重连定时器
    clearTimeout(reconnectTimer);
    
    // 关闭WebSocket连接
    if (socket) {
      try {
        socket.close();
      } catch (e) {
        debugLog('关闭WebSocket出错:', e);
      }
      socket = null;
    }
    
    isConnected = false;
    reconnectCount = 0;
  },
  
  /**
   * 手动发送当前位置
   */
  sendCurrentLocation() {
    if (isConnected) {
      sendLocationData();
    } else {
      debugLog('WebSocket未连接，尝试重新连接');
      reconnectCount = 0;
      initWebSocket();
    }
  },
  
  /**
   * 获取当前连接状态
   */
  isConnected() {
    return isConnected;
  },
  
  /**
   * 手动重连
   */
  reconnect() {
    debugLog('手动触发重连');
    reconnectCount = 0;
    reconnect();
  },
  
  /**
   * 开始高频率位置发送
   */
  startHighFrequencyLocation() {
    startHighFrequencyLocation();
  },
  
  /**
   * 停止所有位置监听方法
   */
  stopAllLocationWatchers() {
    stopAllLocationWatchers();
  },
  
  /**
   * 停止位置服务
   */
  stopLocationService() {
    stopLocationService();
  }
}; 